package com.qms.qep.service.impl;

import java.util.Date;
import java.util.List;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.qms.qep.mapper.InspectionTaskMapper;
import com.qms.qep.domain.InspectionTask;
import com.qms.qep.domain.dto.InspectionTaskDTO;
import com.qms.qep.service.IInspectionTaskService;

/**
 * 检验任务Service业务层处理
 */
@Service
public class InspectionTaskServiceImpl implements IInspectionTaskService {
    @Autowired
    private InspectionTaskMapper inspectionTaskMapper;

    /**
     * 查询检验任务
     * 
     * @param id 检验任务主键
     * @return 检验任务
     */
    @Override
    public InspectionTask selectInspectionTaskById(Integer id) {
        return inspectionTaskMapper.selectInspectionTaskById(id);
    }

    /**
     * 查询检验任务列表
     * 
     * @param inspectionTask 检验任务
     * @return 检验任务
     */
    @Override
    public List<InspectionTask> selectInspectionTaskList(InspectionTask inspectionTask) {
        return inspectionTaskMapper.selectInspectionTaskList(inspectionTask);
    }
    
    /**
     * 查询检验任务DTO列表
     * 
     * @param inspectionTask 检验任务
     * @return 检验任务DTO
     */
    @Override
    public List<InspectionTaskDTO> selectInspectionTaskDTOList(InspectionTask inspectionTask) {
        return inspectionTaskMapper.selectInspectionTaskDTOList(inspectionTask);
    }

    /**
     * 新增检验任务
     * 
     * @param inspectionTask 检验任务
     * @return 结果
     */
    @Override
    public int insertInspectionTask(InspectionTask inspectionTask) {
        // 设置默认值
        if (inspectionTask.getTaskCode() == null || inspectionTask.getTaskCode().isEmpty()) {
            inspectionTask.setTaskCode(generateTaskCode());
        }
        if (inspectionTask.getStatus() == null) {
            inspectionTask.setStatus(1);
        }
        if (inspectionTask.getTaskStatus() == null) {
            inspectionTask.setTaskStatus(1); // 1待检验
        }
        inspectionTask.setCreateTime(new Date());
        return inspectionTaskMapper.insertInspectionTask(inspectionTask);
    }

    /**
     * 修改检验任务
     * 
     * @param inspectionTask 检验任务
     * @return 结果
     */
    @Override
    public int updateInspectionTask(InspectionTask inspectionTask) {
        inspectionTask.setUpdateTime(new Date());
        return inspectionTaskMapper.updateInspectionTask(inspectionTask);
    }

    /**
     * 批量删除检验任务
     * 
     * @param ids 需要删除的检验任务主键
     * @return 结果
     */
    @Override
    public int deleteInspectionTaskByIds(Integer[] ids) {
        return inspectionTaskMapper.deleteInspectionTaskByIds(ids);
    }

    /**
     * 删除检验任务信息
     * 
     * @param id 检验任务主键
     * @return 结果
     */
    @Override
    public int deleteInspectionTaskById(Integer id) {
        return inspectionTaskMapper.deleteInspectionTaskById(id);
    }
    
    /**
     * 分配检验任务
     * 
     * @param inspectionTask 检验任务
     * @return 结果
     */
    @Override
    public int assignInspectionTask(InspectionTask inspectionTask) {
        // 检查参数有效性
        if (inspectionTask == null || inspectionTask.getId() == null) {
            return 0;
        }
        
        try {
            // 只更新必要字段，避免覆盖其他数据
            InspectionTask updateTask = new InspectionTask();
            updateTask.setId(inspectionTask.getId());
            updateTask.setInspector(inspectionTask.getInspector());
            updateTask.setAssignTime(new Date());
            updateTask.setUpdateTime(new Date());
            
            return inspectionTaskMapper.updateInspectionTask(updateTask);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    
    /**
     * 开始检验任务
     * 
     * @param id 检验任务ID
     * @return 结果
     */
    @Override
    public int startInspectionTask(Integer id) {
        InspectionTask task = new InspectionTask();
        task.setId(id);
        task.setTaskStatus(2); // 2检验中
        task.setActualStartTime(new Date());
        task.setUpdateTime(new Date());
        return inspectionTaskMapper.updateInspectionTask(task);
    }
    
    /**
     * 完成检验任务
     * 
     * @param inspectionTask 检验任务
     * @return 结果
     */
    @Override
    public int finishInspectionTask(InspectionTask inspectionTask) {
        inspectionTask.setTaskStatus(3); // 3已完成
        inspectionTask.setActualEndTime(new Date());
        inspectionTask.setActualDate(new Date());
        inspectionTask.setUpdateTime(new Date());
        return inspectionTaskMapper.updateInspectionTask(inspectionTask);
    }
    
    /**
     * 根据状态查询检验任务数量
     * 
     * @param taskStatus 任务状态
     * @return 结果
     */
    @Override
    public int countInspectionTaskByStatus(Integer taskStatus) {
        return inspectionTaskMapper.countInspectionTaskByStatus(taskStatus);
    }
    
    /**
     * 查询检验任务通过情况统计
     * 
     * @return 结果
     */
    @Override
    public List<InspectionTaskDTO> selectInspectionTaskStatistics() {
        try {
            List<InspectionTaskDTO> results = inspectionTaskMapper.selectInspectionTaskStatistics();
            if (results == null || results.isEmpty()) {
                // 如果没有数据，创建默认统计数据
                List<InspectionTaskDTO> defaultStats = new ArrayList<>();
                
                // 创建合格数据
                InspectionTaskDTO passed = new InspectionTaskDTO();
                passed.setInspectionResult("合格");
                passed.setSampleQuantity(0); // 使用sampleQuantity字段存储数量
                defaultStats.add(passed);
                
                // 创建不合格数据
                InspectionTaskDTO failed = new InspectionTaskDTO();
                failed.setInspectionResult("不合格");
                failed.setSampleQuantity(0);
                defaultStats.add(failed);
                
                // 创建特采数据
                InspectionTaskDTO special = new InspectionTaskDTO();
                special.setInspectionResult("特采");
                special.setSampleQuantity(0);
                defaultStats.add(special);
                
                return defaultStats;
            }
            return results;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
    
    /**
     * 查询检验任务月度统计数据
     * 
     * @return 月度统计数据
     */
    @Override
    public List<Map<String, Object>> selectInspectionTaskMonthlyStatistics() {
        try {
            List<Map<String, Object>> results = inspectionTaskMapper.selectInspectionTaskMonthlyStatistics();
            if (results == null || results.isEmpty()) {
                // 如果没有数据，创建默认月度统计数据
                List<Map<String, Object>> defaultStats = new ArrayList<>();
                Calendar cal = Calendar.getInstance();
                int currentYear = cal.get(Calendar.YEAR);
                
                // 为过去12个月创建模拟数据
                for (int i = 0; i < 12; i++) {
                    Map<String, Object> monthData = new HashMap<>();
                    cal.set(Calendar.MONTH, i);
                    String monthStr = (i + 1) + "月";
                    
                    // 设置月份
                    monthData.put("month", monthStr);
                    // 设置任务数量为0
                    monthData.put("taskCount", 0);
                    // 设置合格率为0
                    monthData.put("passRate", 0);
                    
                    defaultStats.add(monthData);
                }
                
                return defaultStats;
            }
            return results;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 自动生成检验任务编号
     * 
     * @return 任务编号
     */
    @Override
    public String generateTaskCode() {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String datePart = now.format(formatter);
        return "QT" + datePart + String.format("%03d", (int) (Math.random() * 1000));
    }
} 